package com.bjsxt.Service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.bjsxt.Service.TbContentCategoryService;
import com.bjsxt.commons.exception.DaoException;
import com.bjsxt.commons.pojo.BaizhanResult;
import com.bjsxt.mapper.TbContentCategoryMapper;
import com.bjsxt.mapper.TbContentMapper;
import com.bjsxt.pojo.TbContent;
import com.bjsxt.pojo.TbContentCategory;
import com.bjsxt.pojo.TbContentCategoryChild;
import com.bjsxt.utils.IDUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Locale;

/**
 * @author coder_z
 * @date 2023/2/13
 **/
@Service
public class TbContentCategoryServiceImpl implements TbContentCategoryService {
    @Autowired
    private TbContentCategoryMapper tbContentCategoryMapper;
    /**
     * 分层查询内容分类
     * @param id
     * @return
     */
    @Override
    public BaizhanResult selectByPid(long id) {
        QueryWrapper<TbContentCategory> wrapper = new QueryWrapper<TbContentCategory>().eq("parent_id", id).eq("status", 1);
//      查询到的结果
        List<TbContentCategory> list = tbContentCategoryMapper.selectList(wrapper);
//      转换后的容器
        ArrayList<TbContentCategoryChild> listResult = new ArrayList<>();
//      转换
        list.forEach(category->{
            TbContentCategoryChild child = new TbContentCategoryChild();
//          按照同名赋值
            BeanUtils.copyProperties(category,child);
            child.setLeaf(!category.getIsParent());
            listResult.add(child);

        });
        return BaizhanResult.ok(listResult);
    }

    /**
     * 新增内容分类
     * @param tbContentCategory
     * @return
     */
    @Override
    public BaizhanResult insert(TbContentCategory tbContentCategory)throws DaoException {
//       先判断名称是否为重复类
        QueryWrapper<TbContentCategory> wrapper = new QueryWrapper<TbContentCategory>().eq("parent_id",tbContentCategory.getParentId())
                .eq("name",tbContentCategory.getName())
                .eq("status",1);
        TbContentCategory tbContentCategory1 = tbContentCategoryMapper.selectOne(wrapper);
//        如果为Null 则说明不重复
        if(tbContentCategory1==null){
            Date date = new Date();
//            一定要先判断修改后 再去新增节点  否则出现恒有子节点
//            判断父节点是否是子节点 如果是子节点则需要修改成父节点
            QueryWrapper<TbContentCategory> wrapper2 = new QueryWrapper<TbContentCategory>().eq("parent_id",tbContentCategory.getParentId())
                    .eq("status",1);
            Integer count = tbContentCategoryMapper.selectCount(wrapper2);
//           为0没有子节点 则该父节点之前一定是子节点 然后设置成父节点
            if(count==0){
                TbContentCategory parent = new TbContentCategory();
                parent.setParentId(tbContentCategory.getParentId());
                parent.setIsParent(true);
                parent.setCreated(date);
                int index= tbContentCategoryMapper.updateById(parent);
//                如果设置成功 则继续执行分类的新增 如果失败 不继续执行 抛出异常 回滚事务
                if(index!=1){
                    throw  new DaoException("服务器消息-修改父分类状态失败");
                }
            }
//            填充数据
            tbContentCategory.setId(IDUtils.genItemId());

            tbContentCategory.setCreated(date);
            tbContentCategory.setUpdated(date);
//            新增节点一定是个子节点
            tbContentCategory.setIsParent(false);
            tbContentCategory.setSortOrder(1);
//            新增节点状态一定是正常的
            tbContentCategory.setStatus(1);
            int index = tbContentCategoryMapper.insert(tbContentCategory);
            if(index==1){
                return  BaizhanResult.ok();
            }
        }

        throw  new DaoException("服务器消息-新增内容分类状态失败");
    }
    @Transactional
    @Override
    public BaizhanResult deleteStatusById(long id) {
        Date date = new Date();
        int result = deleteAllByParentId(id, new Date());
//          确定所有子节点的状态都为2
        if(result==1){
//            必须先删除在判断
//            查询当前节点详细信息 获取当前节点父节点id
            TbContentCategory currentCategory = tbContentCategoryMapper.selectById(id);
//            判断父节点是否还有其他子节点
            QueryWrapper<TbContentCategory> eq = new QueryWrapper<TbContentCategory>().eq("parent_id", currentCategory.getParentId()).eq("status", 1);
//            查询指定父节点下正常状态节点有多少个
            Integer count = tbContentCategoryMapper.selectCount(eq);
            if(count==0){
                TbContentCategory parent = new TbContentCategory();
                parent.setParentId(currentCategory.getParentId());
                parent.setIsParent(true);
                parent.setCreated(date);
                int i = tbContentCategoryMapper.updateById(parent);
                if(i!=1){
                    throw new DaoException("服务器消息，修改父分类失败");
                }
            }
            return BaizhanResult.ok();
        }


        throw new DaoException("服务器消息，删除分类失败");
    }

    /**
     * 修改当前节点名字
     * @param category
     * @return
     */
    @Override
    public BaizhanResult updateNameById(TbContentCategory category) {
//        获取当前节点详细信息
        TbContentCategory currentCategory = tbContentCategoryMapper.selectById(category);
        if(currentCategory.equals(category.getName())){
            return BaizhanResult.error("服务器消息，现名称和原名称相同");
        }
//       判断更改的新名称是否存在 有多少个
        QueryWrapper<TbContentCategory> wrapper = new QueryWrapper<TbContentCategory>().eq("parent_id", currentCategory.getParentId())
                .eq("name",category.getName())
                .eq("status", 1);
        Integer count = tbContentCategoryMapper.selectCount(wrapper);
        if(count>0){
            return BaizhanResult.error("服务器消息，现名称已存在");
        }
//        修改内容
        category.setUpdated(new Date());
        int i = tbContentCategoryMapper.updateById(category);
        if(i==1){
            return BaizhanResult.ok();
        }
        return BaizhanResult.error("服务器消息，修改内容分类失败");
    }

    /**
     * 根据父节点id删除所有子节点
     * @param id
     * @return
     */
    public int deleteAllByParentId(long id,Date date)throws DaoException{
        TbContentCategory Category = new TbContentCategory();
        Category.setId(id);
        Category.setStatus(2);
        Category.setUpdated(date);
        int index = tbContentCategoryMapper.updateById(Category);
        if(index==1){
            QueryWrapper<TbContentCategory> wrapper = new QueryWrapper<TbContentCategory>().eq("parent_id", id).eq("status", 1);
//            查询到父节点下所有子节点
            List<TbContentCategory> list = tbContentCategoryMapper.selectList(wrapper);
            for (TbContentCategory categorychild : list) {
                int result = deleteAllByParentId(categorychild.getId(), date);
                if(result==0){
//            说明修改子节点失败
//                    return 0;
                    throw  new DaoException("服务器消息，修改子节点失败");
                }
            }
            return 1;
        }
        throw  new DaoException("服务器消息，修改节点失败");
    }
}
